package Dominio;

import Datos.CtrlDatos;
import Vistas.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.StreamCorruptedException;
import java.net.MalformedURLException;
import java.util.Vector;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.Collections;

/**
 *
 * @author Sandra Crespo, Juan Manuel Fuentes, Pedro Redondo
 */
public class CtrlDominio {

    private DiccionarioNoticias dN; //Diccionario de noticias clasificadas
    private DiccionarioPalabras dP; //Diccionario de palabras
    private DiccionarioPalabras dPN; //Diccionario de palabras no funcionales
    private DiccionarioTemas dT; //Diccionario de Temas
    private CtrlDatos CD = new CtrlDatos();
    private static CtrlDominio INSTANCE = null;
    static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    static StringBuffer str = new StringBuffer();
    public int actual;
    public int coinci;
    private String fs = System.getProperty("file.separator");

    protected CtrlDominio() {
    }

    private synchronized static void createInstance() {
        if (INSTANCE == null) {
            INSTANCE = new CtrlDominio();
        }
    }

    public static CtrlDominio getInstance() {
        if (INSTANCE == null) {
            createInstance();
        }
        return INSTANCE;
    }

    //El tema se añade al diccionario cuando se de a guardar clasificacion.
    public Vector<String> addTema(Vector<String> llt, String tema) throws EstaTemaDiccionarioException {
        if (dT.estaTema(tema)) {
            throw new EstaTemaDiccionarioException("Ya hay un tema con el nombre: " + tema);
        }
        //Tema t=new Tema(tema);
        llt.add(tema);
        return llt;
    }

    public void guardarClasificacionAutomatica(Vector<AuxNoticia> auto, Vector<AuxNoticia> manual) {
        for (AuxNoticia a : manual) {
            if (!a.temas.isEmpty()) {
                this.guardarClasificacionManual(a);
            }
        }
        for (AuxNoticia a2 : auto) {
            this.guardarClasificacionAutomatica(a2);
        }
        dN.incrementarAutomatico(auto.size());
    }

    public int sizeDic(int dic) {
        switch (dic) {
            case 1:
                while (dP == null) {
                }
                return dP.getTotalPalabras();
            case 2:
                while (dPN == null) {
                }
                return dPN.getTotalPalabras();
        }
        return 0;
    }

    public void guardarClasificacionAutomatica(AuxNoticia aux) {
        NoticiaClasificada nc = new NoticiaClasificada(aux.titulo, aux.path, aux.seccion);
        addTemasAuto(aux.temas, nc);
        addNoticiasAuto(aux.palabras, nc);
        dN.addNoticiaClasificada(nc);
    }

    public void guardarClasificacionManual(AuxNoticia aux) {
        NoticiaClasificada nc = new NoticiaClasificada(aux.titulo, aux.path, aux.seccion);
        addTemas(nc, aux.temas, aux.palabras, aux.seccion);
        incrementarMarcar(aux.palabras, aux.seccion);
        dN.addNoticiaClasificada(nc);
    }

    public void guardarClasificacionManualXML(AuxNoticia aux) throws IOException, NoEstaTemaException {
        StringBuffer sb = new StringBuffer();
        StringBuffer palcl = new StringBuffer();
        Vector<String> vs = new Vector<String>(0, 1);
        sb.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n");
        sb.append("<NOTICIACLASIFICADA>\n");
        sb.append("<TITLE>" + aux.titulo + "</TITLE>\n");
        sb.append("<P>" + aux.texto + "</P>\n");
        for (int i = 0; i < aux.palabrascl.size(); i++) {
            palcl.append(aux.palabrascl.get(i) + ", ");
        }
        for (int i = 0; i < aux.palabras.size(); i++) {
            if (aux.palabras.get(i).frec >= 2) {
                palcl.append(aux.palabras.get(i).pal + ", ");
            }
        }
        sb.append("<PALABRASCLAVE>" + palcl + "</PALABRASCLAVE>\n");
        palcl = new StringBuffer();
        for (int i = 0; i < aux.temas.size(); i++) {
            palcl.append(aux.temas.get(i) + ", ");
        }
        sb.append("<TEMASRELACIONADOS>" + palcl + "</TEMASRELACIONADOS>\n");
        palcl = new StringBuffer();
        Vector<String> auxvec = new Vector<String>(0, 1);
        for (int i = 0; i < aux.temas.size(); i++) {
            vs = listarNoticasTema(aux.temas.get(i));
            for (int j = 0; j < vs.size(); j++) {
                if ((vs.get(j)).compareTo(aux.titulo) != 0 && !auxvec.contains(vs.get(j))) {
                    palcl.append(vs.get(j) + ", ");
                    auxvec.add(vs.get(j));
                }
            }
        }
        sb.append("<NOTICIASRELACIONADAS>" + palcl + "</NOTICIASRELACIONADAS>\n");
        sb.append("</NOTICIACLASIFICADA>\n");
        CD.setString(sb.toString(), System.getProperty("user.dir")+ fs + "NoticiasXML" + fs + aux.titulo + ".xml");

    }

    public boolean estaDiccionarioNoticias(String titulo) {
        return dN.estaNoticia(titulo);
    }

    public VecTitTex clasificar(String pa) throws NoticiaNoValidaException, NullPointerException, MalformedURLException, IOException {
        Vector<String> vec = new Vector<String>(0, 1);
        TitTex tt = new TitTex();
        Texto tx;
        VecTitTex vtt = new VecTitTex();


        if (pa.substring(0, 4).compareTo("http") == 0) {
            URL page = new URL(pa);
            HttpURLConnection conn = (HttpURLConnection) page.openConnection();
            conn.connect();
            InputStreamReader inr = new InputStreamReader((InputStream) conn.getContent(), "UTF-8");
            BufferedReader buff = new BufferedReader(inr);
            String line;
            do {
                line = buff.readLine();
                str.append(line + " ");
            } while (line != null);
            URLEncoder.encode(str.toString(), "UTF-8");
            ParserHttp not = new ParserHttp();
            tt = not.sacaTexto(str);

        } else if ((pa.substring(pa.length() - 4, pa.length()).compareTo(".txt") == 0)) {
            String text = CD.getString(pa);
            URLEncoder.encode(text, "UTF-8");
            ParserTXT not = new ParserTXT();
            tt = not.sacaTexto(new StringBuffer(text));
        } else {
            String text = CD.getString(pa);
            URLEncoder.encode(text, "UTF-8");
            ParserDisc not = new ParserDisc();
            tt = not.sacaTexto(new StringBuffer(text));
        }
        str = new StringBuffer("");
        tx = new Texto(tt.texto, dPN);
        vtt.vec = new Vector<FrecPal>();
        vtt.vec = tx.consultarClaves();
        Collections.sort(vtt.vec);
        Collections.reverse(vtt.vec);
        vtt.tit = tt.titulo;
        vtt.texto = tt.texto;
        vtt.palclave = tx.consultarBiClaves();
        Collections.sort(vtt.palclave);
        Collections.reverse(vtt.palclave);
        return vtt;

    }

    public Vector<String> listarPalabras() {
        int tam = dP.getTotalPalabras();
        Vector<String> palabras = new Vector<String>();
        for (int i = 1; i < tam + 1; i++) {
            palabras.add(dP.consultarPalabra(i).getValor());
        }
        return palabras;
    }

    public Vector<String> listarTemaPalabra(String palabra) {
        int id = dP.existPalabra(palabra);
        PalabraParaAnadir p = (PalabraParaAnadir) dP.consultarPalabra(id);
        Vector<String> temas = new Vector<String>();
        for (Tema t : p.getTemas()) {
            temas.add(t.getNombre());
        }
        return temas;
    }

    public Vector<Strouble> sacaTemas(VecTitTex vtt, String seccion) {
        FrecPal fp;
        Vector<Strouble> vs = new Vector<Strouble>(0, 1);
        Vector<IdFrec> vif = new Vector<IdFrec>(0, 1);
        int id;
        for (int i = 0; i < vtt.vec.size(); i++) {
            fp = (FrecPal) vtt.vec.get(i);
            if (dP.existLetra(fp.pal.charAt(0))) {
                id = dP.existPalabra(fp.pal);
                if (id != 0) {
                    if (dP.palabraActivada(fp.pal)) {
                        IdFrec idf = new IdFrec();
                        idf.id = id;
                        idf.frec = fp.frec;
                        vif.add(idf);
                    }
                }
            }
        }

        Vector<Tema> vt = dT.getTemas(seccion);
        for (Tema t : vt) {
            Strouble st = new Strouble();
            st.dist = t.getDistancia(vif, dN.sizeNoticiasClasificadas(seccion), dP, seccion) * 100;
            st.nom = t.getNombre();
            vs.add(st);
        }
        Collections.sort(vs);
        return vs;
    }

    public boolean existeNoticia(String p) {
        return dN.estaNoticia(p);
    }

    public Vector<Boolean> existenNoticias(Vector<String> pal) {
        Vector<Boolean> b = new Vector<Boolean>();
        for (String p : pal) {
            if (dN.estaNoticia(p)) {
                b.add(true);
            } else {
                b.add(false);
            }
        }
        return b;
    }

    private void addNoticiasAuto(Vector<FrecPal> palabras, NoticiaClasificada nc) {
        for (FrecPal pal : palabras) {
            if (dP.existLetra(pal.pal.charAt(0))) {
                int i = dP.existPalabra(pal.pal);
                IdFrec pfrec = new IdFrec();
                if (i != 0) {
                    pfrec.id = i;
                    pfrec.frec = pal.frec;
                    nc.addPalabra(pfrec);
                }
            }
        }
    }

    private void addTemasAuto(Vector<String> temas, NoticiaClasificada nc) {
        for (String t : temas) {
            if (dT.estaTema(t)) {
                try {
                    nc.addTema(dT.getTema(t));
                } catch (NoEstaTemaException ex) {
                }
            }
        }
    }

    private void crearDicc(String path, int op) throws Exception {
        String s = CD.getString(path);
        
        StringTokenizer st = new StringTokenizer(s);
        Integer q = new Integer(Integer.parseInt(st.nextToken()));
        this.actual = q;
        PalabraParaAnadir[] x = new PalabraParaAnadir[q];
        for (int i = 0; i < q; i++) {
            x[i] = new PalabraParaAnadir();
        }
        String pal;
        char[] nacc = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
        char[] acc = {'\u00c0', '\u00c1', '\u00c2', '\u00c4', '\u00c8', '\u00c9', '\u00ca', '\u00cb', '\u00cc', '\u00cd', '\u00ce', '\u00cf', '\u00d2', '\u00d3', '\u00d4', '\u00d6', '\u00d9', '\u00da', '\u00db', '\u00dc', '\u00e0', '\u00e1', '\u00e2', '\u00e4', '\u00e8', '\u00e9', '\u00ea', '\u00eb', '\u00ec', '\u00ed', '\u00ee', '\u00ef', '\u00f2', '\u00f3', '\u00f4', '\u00f6', '\u00f9', '\u00fa', '\u00fb', '\u00fc'};
        for (int i = 0; i < q; i++) {
            pal = st.nextToken();
            for (int j = 0; j < acc.length; j++) {

                pal = pal.replace(acc[j], nacc[j / 4]);

            }
            x[i].setValor(pal);
            if (op == 1) {
                if (dP.existLetra(x[i].getValor().charAt(0))) {
                    if (dP.existPalabra(x[i].getValor()) == 0) {
                        dP.addPalabra(x[i]);
                    }
                }
            } else {
                if (dPN.existLetra(x[i].getValor().charAt(0))) {
                    if (dPN.existPalabra(x[i].getValor()) == 0) {
                        dPN.addPalabra(x[i]);
                    }
                }
            }
        }
    }

    public void crearDiccFile(int idi, int dic, String path) throws Exception {
        String fs = System.getProperty("file.separator");
        switch (dic) {
            case 1:
                dP = new DiccionarioPalabras();
                dP.crearDiccionarioVacio();
                crearDicc(path, 1);
                break;
            case 2:
                dPN = new DiccionarioPalabras();
                dPN.crearDiccionarioVacio();
                crearDicc(path, 2);
                break;
        }
        switch (idi) {
            case 1:
                guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "Diccionarios" + fs + "DPesp.dicc");
                guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") +fs + "Diccionarios" + fs + "DNFesp.dicc");
                break;
            case 2:
                guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "Diccionarios" + fs + "DPcat.dicc");
                guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "Diccionarios" + fs + "DNFcat.dicc");
                break;
            case 3:
                guardarDiccionarioPalabras(System.getProperty("user.dir") + fs + "Diccionarios" + fs + "DPing.dicc");
                guardarDiccionarioPalabrasNoFunc(System.getProperty("user.dir") + fs + "Diccionarios" + fs + "DNFing.dicc");
                break;
        }


    }

    public boolean estaDiccionarioTemas(String tema) {
        return dT.estaTema(tema);
    }

    public Vector<String> listarTemas() {
        Vector<String> temas = new Vector<String>(0, 1);
        for (Tema t : dT.getTemas()) {
            temas.add(t.getNombre());
        }
        return temas;
    }

    public Vector<String> listarNoticias() {
        Vector<String> noticias = new Vector<String>(0, 1);
        for (NoticiaClasificada nc : dN.getNoticiaClasificadas()) {
            noticias.add(nc.getTitulo());
        }
        return noticias;
    }

    public String getPath(String noticia) throws NoEstaNoticiaException {
        NoticiaClasificada nclas = dN.getNoticiaClasificada(noticia);
        return nclas.getPath();
    }

    public Vector<String> listarTemaNoticia(String noticia) throws NoEstaNoticiaException {
        Vector<String> tema = new Vector<String>(0, 1);
        NoticiaClasificada nc = dN.getNoticiaClasificada(noticia);
        for (Tema t : nc.getTemas()) {
            tema.add(t.getNombre());
        }
        return tema;
    }

    public Vector<String> listarPalabrasNoticia(String noticia) throws NoEstaNoticiaException {
        Vector<String> palabras = new Vector<String>(0, 1);
        NoticiaClasificada nc = dN.getNoticiaClasificada(noticia);
        for (int p : nc.getPalabras()) {
            palabras.add(dP.consultarPalabra(p).getValor());
        }
        return palabras;
    }

    public Vector<String> listarNoticasTema(String tema) throws NoEstaTemaException {
        Vector<String> noticias = new Vector<String>(0, 1);
        Tema t = dT.getTema(tema);
        for (NoticiaClasificada nc : t.getNoticiasClasificadas()) {
            noticias.add(nc.getTitulo());
        }
        return noticias;
    }

    /*public TemaPalabra consultarNoticias(String not) throws NoEstaNoticiaException {
        TemaPalabra tp = new TemaPalabra();
        tp.palabras = new Vector<String>(0, 1);
        tp.temas = new Vector<String>(0, 1);
        NoticiaClasificada nc = dN.getNoticiaClasificada(not);
        tp.palabras = listarPalabras(nc);
        tp.temas = listarTemas(nc);
        return tp;
     * 
    }*/
    
    
    public void cargarDiccionarios(String pathNot, String pathPal, String pathTem, String pathPalNoFunc) {
        cargarDiccionarioPalabras(pathPal);
        cargarDiccionarioNoticias(pathNot);
        cargarDiccionarioPalabrasNoFunc(pathPalNoFunc);
        cargarDiccionarioTemas(pathTem);
    }

    public void actualizar(String pathNot, String pathPal, String pathTem, String pathPalNoFunc) {
        guardarDiccionarioNoticias(pathNot);
        guardarDiccionarioTemas(pathTem);
        guardarDiccionarioPalabras(pathPal);
        //necesaria¿??
        guardarDiccionarioPalabrasNoFunc(pathPalNoFunc);
    }

    private void addTemas(NoticiaClasificada nc, Vector<String> temas, Vector<FrecPal> palabras, String seccion) {
        for (String tma : temas) {
            try {
                Tema t = dT.getTema(tma);
                if (seccion.equals(t.getSeccion())) {
                    nc.addTema(t);
                    t.addNoticiaClasificada(nc);
                    addPalabras(nc, t, palabras);
                }
            } catch (NoEstaTemaException ex) {
                Tema t = new Tema(tma, seccion);
                nc.addTema(t);
                dT.addTema(t);
                t.addNoticiaClasificada(nc);
                addPalabras(nc, t, palabras);
            }
        }
    }

    public String getSeccionTema(String t) throws NoEstaTemaException {
        Tema tema = dT.getTema(t);
        return tema.getSeccion();
    }
    
    
    public String getSeccionNoticia(String not) throws NoEstaNoticiaException{
        NoticiaClasificada nc=dN.getNoticiaClasificada(not);
        return nc.getSeccion();
    }

    public Vector<String> listarTemasSeccion(String seccion) {
        Vector<String> secc = new Vector<String>();
        Vector<Tema> vt = dT.getTemas(seccion);
        for (Tema t : vt) {
            secc.add(t.getNombre());
        }
        return secc;
    }

    public Vector<String> listarPalabrasTema(String t) throws NoEstaTemaException {
        Vector<String> p = new Vector<String>();
        for (PalabraParaAnadir tx : dT.getTema(t).getPalabras()) {
            p.add(tx.valor);
        }

        return p;
    }

    public Vector<String> listarTemasPalabra(String p) {
        Vector<String> t = new Vector<String>();
        int i = dP.existPalabra(p);
        PalabraParaAnadir pa = (PalabraParaAnadir) dP.consultarPalabra(i);
        for (Tema tx : pa.getTemas()) {
            t.add(tx.getNombre());
        }

        return t;
    }

    private void addPalabras(NoticiaClasificada nc, Tema tema, Vector<FrecPal> palabras) {
        for (FrecPal pal : palabras) {
            if (dP.existLetra(pal.pal.charAt(0))) {
                int i = dP.existPalabra(pal.pal);
                PalFrec pfrec = new PalFrec();
                if (i == 0) {
                    pfrec.p = new PalabraParaAnadir(pal.pal);
                    pfrec.frec = pal.frec;
                    dP.addPalabra(pfrec.p);
                } else {
                    pfrec.p = (PalabraParaAnadir) dP.consultarPalabra(i);
                    pfrec.frec = pal.frec;
                }

                IdFrec ix=new IdFrec();
                ix.id=dP.existPalabra(pal.pal);
                ix.frec=pal.frec;
                nc.addPalabra(ix);
                //pfrec.p.marcarPalabra();
                //pfrec.p.incApariciones();

                if (!pfrec.p.estaTema(tema)) {
                    pfrec.p.anadirTema(tema);
                }

                if (!tema.esPalabraClave(pal.pal)) {
                    tema.addPalabra(pfrec.p);
                }

            }
        }
    }

    private void cargarDiccionarioTemas(String pathTem) {
        try {
            dT = (DiccionarioTemas) CD.getObject(pathTem);
        } catch (StreamCorruptedException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dT = new DiccionarioTemas();
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void cargarDiccionarioNoticias(String pathNot) {
        try {
            dN = (DiccionarioNoticias) CD.getObject(pathNot);
        } catch (StreamCorruptedException ex) {
            Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dN = new DiccionarioNoticias();
        } catch (IOException ex) {
            Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }

    }

    private void cargarDiccionarioPalabras(String pathPal) {
        try {
            dP = (DiccionarioPalabras) CD.getObject(pathPal);
        } catch (StreamCorruptedException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dP = new DiccionarioPalabras();
            dP.crearDiccionarioVacio();
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
        // Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void cargarDiccionarioPalabrasNoFunc(String pathPalNoFunc) {
        try {
            dPN = (DiccionarioPalabras) CD.getObject(pathPalNoFunc);
        } catch (StreamCorruptedException ex) {
        //  Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
            dPN = new DiccionarioPalabras();
            dPN.crearDiccionarioVacio();
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ClassNotFoundException ex) {
        //    Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void guardarDiccionarioNoticias(String pathNot) {
        try {
            CD.setObject(dN, pathNot);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void guardarDiccionarioPalabras(String pathPal) {
        try {
            CD.setObject(dP, pathPal);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void guardarDiccionarioPalabrasNoFunc(String pathPalNoFunc) {
        try {
            CD.setObject(dPN, pathPalNoFunc);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void guardarDiccionarioTemas(String pathTem) {
        try {
            CD.setObject(dT, pathTem);
        } catch (SecurityException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (FileNotFoundException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
        //Logger.getLogger(CtrlDominio.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    private void incrementarMarcar(Vector<FrecPal> palabras, String seccion) {
        for (FrecPal fp : palabras) {
            if (dP.existLetra(fp.pal.charAt(0))) {
                int i = dP.existPalabra(fp.pal);
                PalabraParaAnadir p = (PalabraParaAnadir) dP.consultarPalabra(i);
                p.incApariciones(seccion);
                p.marcarPalabra();
            }

        }
    }

    private Vector<String> listarPalabras(NoticiaClasificada nc) {
        Vector<String> palabras = new Vector<String>(0, 1);
        for (int pa : nc.getPalabras()) {
            palabras.add(dP.consultarPalabra(pa).getValor());
        }

        return palabras;
    }

    private Vector<String> listarTemas(NoticiaClasificada nc) {
        Vector<String> temas = new Vector<String>(0, 1);
        for (Tema t : nc.getTemas()) {
            temas.add(t.getNombre());
        }

        return temas;
    }
}
